/**
 * 计算两个字符串s和t的相似度。
 * 相似度定义为两个字符串经过最小编辑距离处理后，长度比例的百分比。
 * 最小编辑距离是指将一个字符串转换成另一个字符串所需的最少操作次数，操作包括插入、删除和替换字符。
 *
 * @param s 第一个字符串
 * @param t 第二个字符串
 * @param f 保留小数位数，可选参数，默认为2
 * @return 返回两个字符串的相似度，百分比形式
 */
const strSimilar = (s, t, f) => {
    // 如果任一字符串为null，则相似度为0
    if (!s || !t) {
        return 0
    }
    // 如果两个字符串相同，则相似度为100
    if (s === t) {
        return 100;
    }
    // 计算较长字符串的长度
    var l = s.length > t.length ? s.length : t.length
    // s的长度
    var n = s.length
    // t的长度
    var m = t.length
    // 初始化动态规划矩阵，d[i][j]表示s的前i个字符与t的前j个字符的最小编辑距离
    var d = []
    // 设置精度，如果f为null则默认为2
    f = f || 2
    var min = function (a, b, c) {
        return a < b ? (a < c ? a : c) : (b < c ? b : c)
    }
    // 初始化矩阵的第一列和第一行
    var i, j, si, tj, cost
    if (n === 0) return m
    if (m === 0) return n
    for (i = 0; i <= n; i++) {
        d[i] = []
        d[i][0] = i
    }
    for (j = 0; j <= m; j++) {
        d[0][j] = j
    }
    // 动态规划计算最小编辑距离
    for (i = 1; i <= n; i++) {
        si = s.charAt(i - 1)
        for (j = 1; j <= m; j++) {
            tj = t.charAt(j - 1)
            // 计算字符替换的成本，相同字符成本为0，不同字符成本为1
            if (si === tj) {
                cost = 0
            } else {
                cost = 1
            }
            d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost)
        }
    }
    // 计算相似度，公式为(1 - 最小编辑距离/较长字符串长度) * 100
    let res = (1 - d[n][m] / l) * 100
    // 根据f的值四舍五入保留相应的小数位数
    return res.toFixed(f)
}

const formatTimestamp = (timestamp, type) => {
    const date = new Date(timestamp); // 创建 Date 对象

    const year = date.getFullYear(); // 获取年份
    const month = String(date.getMonth() + 1).padStart(2, '0'); // 获取月份
    const day = String(date.getDate()).padStart(2, '0'); // 获取日期
    const hours = String(date.getHours()).padStart(2, '0'); // 获取小时
    const minutes = String(date.getMinutes()).padStart(2, '0'); // 获取分钟
    const seconds = String(date.getSeconds()).padStart(2, '0'); // 获取秒

    if (type === 'MM-DD HH:mm') {
        return `${month}-${day} ${hours}:${minutes}`;
    } else if (type === 'MM-DD') {
        return `${month}-${day}`;
    } else if (type === 'HH:mm') {
        return `${hours}:${minutes}`;
    } else if (type === 'YYYY-MM-DD') {
        return `${year}-${month}-${day}`;
    } else if (type === 'YYYY-MM-DD HH:mm:ss') {
        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
    } else if (type === 1) {
        // 获取今天的日期
        const today = new Date();
        today.setHours(0, 0, 0, 0); // 重置时间为 00:00:00

        // 获取昨天的日期
        const yesterday = new Date(today);
        yesterday.setDate(today.getDate() - 1); // 昨天的日期

        const currentYear = new Date().getFullYear(); // 获取当前年份
        const dateYear = date.getFullYear(); // 获取给定日期的年份

        // 判断日期
        if (date >= today) {
            return "今天";
        } else if (date >= yesterday) {
            return "昨天";
        } else if (dateYear === currentYear) {
            return `${month}-${day}`;
        } else {
            return `${year}-${month}-${day}`;
        }
    } else {
        // 获取今天的日期
        const today = new Date();
        today.setHours(0, 0, 0, 0); // 重置时间为 00:00:00

        // 获取昨天的日期
        const yesterday = new Date(today);
        yesterday.setDate(today.getDate() - 1); // 昨天的日期

        const currentYear = new Date().getFullYear(); // 获取当前年份
        const dateYear = date.getFullYear(); // 获取给定日期的年份

        // 判断日期
        if (date >= today) {
            // return "今天";
            return `${hours}:${minutes}`;
        } else if (date >= yesterday) {
            return "昨天 " + yesterday.getHours() + ":" + yesterday.getMinutes();
        } else if (dateYear === currentYear) {
            return `${month}-${day} ${hours}:${minutes}`;
        } else {
            return `${year}-${month}-${day} ${hours}:${minutes}`;
        }
    }
};

const isMoreThanTwoMinutes = (timestamp1, timestamp2, num) => {
    const differenceInMilliseconds = Math.abs(timestamp1 - timestamp2); // 计算时间差（毫秒）
    const differenceInMinutes = differenceInMilliseconds / (1000 * 60); // 转换为分钟

    return differenceInMinutes > 1; // 判断是否大于 1 分钟
};

const getTimeRange = (range) => {
    const now = new Date();
    const end = new Date(now);
    let start;

    switch (range) {
        case 'oneDay':
            start = new Date(now);
            start.setDate(now.getDate() - 1);
            break;
        case 'threeDay':
            start = new Date(now);
            start.setDate(now.getDate() - 3);
            break;
        case 'sevenDay':
            start = new Date(now);
            start.setDate(now.getDate() - 7);
            break;
        case 'oneMonth':
            start = new Date(now);
            start.setMonth(now.getMonth() - 1);
            break;
        case 'sixMonth':
            start = new Date(now);
            start.setMonth(now.getMonth() - 6);
            break;
        case 'oneYear':
            start = new Date(now);
            start.setFullYear(now.getFullYear() - 1);
            break;
        default:
            throw new Error('不支持的时间范围');
    }

    return {
        start: formatDate(start),
        end: formatDate(end)
    };
}

function formatDate(date) {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    return `${year}-${month}-${day}`;
}



export {
    strSimilar,
    formatTimestamp,
    isMoreThanTwoMinutes,
    getTimeRange
}
